Listes : indices et parcours
Une liste contient plusieurs valeurs dans un ordre précis. Chaque position possède un indice positif depuis le début et un indice négatif depuis la fin.
1. Créer une liste
notes = [4, 5.5, 3, 6]
noms = ["Alice", "Bob", "Claire"]
vide = []
2. Comprendre les indices
| Élément recherché | Écriture | Avec L = [10, 20, 30, 40, 50] |
|---|---|---|
| Premier | L[0] | 10 |
| Deuxième | L[1] | 20 |
| Dernier | L[-1] | 50 |
| Avant-dernier | L[-2] | 40 |
L = [10, 20, 30, 40, 50]
print(L[0]) # premier
print(L[1]) # deuxième
print(L[-1]) # dernier
print(L[-2]) # avant-dernier
20
50
40
L[1] ou L[-2], vérifie que la liste contient au moins deux éléments : if len(L) >= 2:.3. len() : nombre d’éléments
L = [10, 20, 30, 40, 50]
print(len(L))Les indices positifs valides vont de 0 à len(L) - 1. Ici, le dernier indice positif est donc 4.
4. Parcourir directement les valeurs
L = [10, 20, 30, 40, 50]
for valeur in L:
print(valeur)
Choisis cette forme lorsque tu as besoin des valeurs, mais pas de leur position.
5. Parcourir tous les indices
L = [10, 20, 30, 40, 50]
for i in range(len(L)):
print("indice", i, "valeur", L[i])
indice 1 valeur 20
indice 2 valeur 30
indice 3 valeur 40
indice 4 valeur 50
Cette forme est utile lorsque la position i doit aussi être connue ou modifiée.
6. Parcourir entre deux bornes
L = [10, 20, 30, 40, 50]
debut = 1
fin = 4
for i in range(debut, fin):
print(L[i])
30
40
range(debut, fin) inclut la borne debut, mais exclut la borne fin. Les indices parcourus sont donc 1, 2 et 3.7. Parcourir du deuxième au dernier
L = [10, 20, 30, 40, 50]
for i in range(1, len(L)):
print(L[i])
30
40
50
On commence à l’indice 1. La valeur len(L) est exclue, donc le dernier indice utilisé est bien len(L) - 1.
8. Parcourir un élément sur deux
L = [10, 20, 30, 40, 50]
for i in range(0, len(L), 2):
print(L[i])
30
50
Le troisième argument de range est le pas. Ici, l’indice avance de 2 en 2.
9. Parcourir en sens inverse
L = [10, 20, 30, 40, 50]
for i in range(len(L) - 1, -1, -1):
print(L[i])
40
30
20
10
Le parcours commence au dernier indice, s’arrête avant -1 et recule avec un pas de -1.
10. Extraire une partie avec une tranche
L = [10, 20, 30, 40, 50]
print(L[1:4]) # indices 1 à 3
print(L[:3]) # du début à l’indice 2
print(L[2:]) # de l’indice 2 jusqu’à la fin
[10, 20, 30]
[30, 40, 50]
Comme avec range, L[debut:fin] inclut debut et exclut fin.
11. Modifier et ajouter
L = [10, 20, 30]
L[1] = 25 # remplace le deuxième élément
L.append(40) # ajoute un élément à la fin
print(L)
Supprimer un élément
L = [10, 25, 30, 40]
L.remove(25) # supprime la valeur 25
L.pop() # supprime le dernier élément
print(L)
12. Calculer une somme et une moyenne avec une boucle
notes = [4, 5.5, 3, 6]
total = 0
for note in notes:
total = total + note
if len(notes) > 0:
moyenne = total / len(notes)
print(moyenne)
13. Trouver les deux valeurs extrêmes manuellement
notes = [4, 5.5, 3, 6]
plus_petite = notes[0]
plus_grande = notes[0]
for note in notes:
if note < plus_petite:
plus_petite = note
if note > plus_grande:
plus_grande = note
print("Plus petite :", plus_petite)
print("Plus grande :", plus_grande)
Plus grande : 6
Le premier élément sert de valeur provisoire. Chaque élément suivant est comparé, puis remplace la valeur provisoire si nécessaire.
14. Trouver la plus grande valeur et son indice
notes = [4, 5.5, 3, 6]
plus_grande = notes[0]
indice_plus_grande = 0
for i in range(1, len(notes)):
if notes[i] > plus_grande:
plus_grande = notes[i]
indice_plus_grande = i
print(plus_grande, indice_plus_grande)
15. Compter selon une condition
notes = [4, 5.5, 3, 6]
compteur = 0
for note in notes:
if note < 4:
compteur = compteur + 1
print(compteur)
16. Traiter le cas d’une liste vide
notes = []
if len(notes) == 0:
print("Aucune note")
else:
total = 0
for note in notes:
total = total + note
print(total / len(notes))
L[0] ou de diviser par len(L).17. Compter les occurrences dans une liste
Une occurrence est une apparition d’une valeur. Ici, 6 apparaît trois fois, 5 deux fois, 4 deux fois et 7 six fois. Dans d’autres cours, on appelle parfois une liste Python un « tableau ».
liste = [6, 6, 6, 5, 5, 4, 4, 7, 7, 7, 7, 7, 7]
for nombre in liste:
print(nombre, ":", liste.count(nombre))6 : 3
6 : 3
5 : 2
5 : 2
4 : 2
4 : 2
7 : 6
7 : 6
7 : 6
7 : 6
7 : 6
7 : 6
liste.count(nombre) compte la valeur demandée dans toute la liste. Comme la boucle passe sur chaque élément, elle affiche plusieurs fois les mêmes nombres. Pour les afficher une seule fois, on mémorise les valeurs déjà traitées :
liste = [6, 6, 6, 5, 5, 4, 4, 7, 7, 7, 7, 7, 7]
deja_vu = []
for nombre in liste:
if nombre not in deja_vu:
print(nombre, ":", liste.count(nombre))
deja_vu.append(nombre)5 : 2
4 : 2
7 : 6
Sans count() et sans dictionnaire : la boucle extérieure choisit un nombre inédit ; la boucle intérieure parcourt toute la liste et ajoute 1 chaque fois qu’elle retrouve ce nombre.
liste = [6, 6, 6, 5, 5, 4, 4, 7, 7, 7, 7, 7, 7]
deja_vu = []
for nombre in liste:
if nombre not in deja_vu:
compteur = 0
for x in liste:
if x == nombre:
compteur += 1
print(nombre, ":", compteur)
deja_vu.append(nombre)5 : 2
4 : 2
7 : 6
| Instruction | Ce qu’elle fait |
|---|---|
nombre | La valeur que l’on cherche, par exemple 6. |
compteur = 0 | Repart de zéro pour chaque nouvelle valeur. |
for x in liste | Regarde toutes les valeurs de la liste. |
if x == nombre | Vérifie si la valeur observée est celle recherchée. |
compteur += 1 | Ajoute une occurrence ; équivaut à compteur = compteur + 1. |
deja_vu.append(nombre) | Évite de recompter et de réafficher cette valeur. |
18. Compter avec un dictionnaire : clé et valeur
occurrences = {} crée un dictionnaire vide. Un dictionnaire associe une clé à une valeur. Ici, la clé est le nombre trouvé dans la liste ; la valeur est son compteur. Les accolades {} créent le dictionnaire ; les crochets [clé] choisissent une clé.
liste = [6, 6, 6, 5, 5, 4, 4, 7, 7, 7, 7, 7, 7]
occurrences = {}
for nombre in liste:
if nombre in occurrences:
occurrences[nombre] += 1
else:
occurrences[nombre] = 1
print(occurrences)La clé est donnée dans le else. Au premier tour, nombre vaut 6, donc occurrences[nombre] = 1 signifie occurrences[6] = 1 : cela crée la clé 6 et lui associe la valeur 1. Quand 6 revient, if nombre in occurrences est vrai, car cette clé existe. Alors occurrences[6] += 1 remplace son compteur par 2, puis par 3.
| Tour | nombre | Action | Dictionnaire après le tour |
|---|---|---|---|
| Départ | aucun | Créer le dictionnaire vide | {} |
| 1 | 6 | occurrences[6] = 1 : créer la clé | {6: 1} |
| 2 | 6 | occurrences[6] += 1 | {6: 2} |
| 3 | 6 | occurrences[6] += 1 | {6: 3} |
| 4 | 5 | occurrences[5] = 1 : créer une autre clé | {6: 3, 5: 1} |
| Fin | 7 | Chaque valeur a été traitée | {6: 3, 5: 2, 4: 2, 7: 6} |
La règle à retenir est dictionnaire[clé] = valeur. Une affectation crée la clé si elle n’existe pas ; sinon elle remplace sa valeur. if nombre in occurrences teste la présence d’une clé, pas la présence du nombre parmi les compteurs.
Pour obtenir la même présentation que les méthodes précédentes, parcours les clés du dictionnaire. Voici un exemple autonome avec le dictionnaire déjà rempli :
occurrences = {6: 3, 5: 2, 4: 2, 7: 6}
for nombre in occurrences:
print(nombre, ":", occurrences[nombre])5 : 2
4 : 2
7 : 6
deja_vu et deux boucles. Le dictionnaire permet ensuite de compter en un seul parcours de la liste.